package org.darkforest.common.util;

import java.util.ArrayList;
import java.util.List;

import org.darkforest.model.ArticleClass;
import org.darkforest.model.GoodsClass;

public class TreeListUtil {

    // GoodsClass
    private List<GoodsClass> resultGoodsNodes = null;
    private List<GoodsClass> goodsClassNodes = null;

    // ArticleClass
    private List<ArticleClass> resultArticleNodes = null;
    private List<ArticleClass> articleClassNodes = null;

    /**
     *  构造函数
     */
    public  TreeListUtil() {}

    /************** GoodsClass GoodsClass  start*****************/
    /**
     *  商品分类
     * @param nodes
     */
    public void setGoodsClassNodes(List<GoodsClass> nodes) {
        this.goodsClassNodes = nodes;
    }

    /**
     * 构建树形结构list
     * @return 返回树形结构List列表
     */
    public List<GoodsClass> buildGoodsClassTree() {
        resultGoodsNodes = new ArrayList<GoodsClass>();
        for (GoodsClass node : this.goodsClassNodes) {
            // 一级节点
            if (node.getGcParentId() == 0) {
                resultGoodsNodes.add(node);
                // 递归获取二级、三级、。。。节点
                buildGoodsClass(node);
            }
        }
        return resultGoodsNodes;
    }

    /**
     *  递归循环子节点
     * @param node  当前节点
     */
    private void buildGoodsClass(GoodsClass node) {
        List<GoodsClass> children = new ArrayList<GoodsClass>();
        int id = node.getGcId();
        for (GoodsClass child : this.goodsClassNodes) {
            //如果id等于父id、将该节点加入循环列表中
            if (id == child.getGcParentId()) {
                children.add(child);
            }
        }

        //如果存在子节点、将子节点遍历加入返回值中
        if (!children.isEmpty()) {
            for (GoodsClass child : children) {
                resultGoodsNodes.add(child);
                buildGoodsClass(child);
            }
            node.setGcChildrenId(1);  // 有子节点时，就设为1
        } else {
            node.setGcChildrenId(0);    // 没有子节点时，就设为0
        }
    }
    /************** GoodsClass GoodsClass  end*****************/

    /************** ArticleClass ArticleClass  start*****************/
    /**
     *  文章分类
     * @param nodes
     */
    public void setArticleClassNodes(List<ArticleClass> nodes) {
        this.articleClassNodes = nodes;
    }

    /**
     * 构建树形结构list
     * @return 返回树形结构List列表
     */
    public List<ArticleClass> buildArticleClassTree() {
        resultArticleNodes = new ArrayList<ArticleClass>();
        for (ArticleClass node : this.articleClassNodes) {
            // 一级节点
            if (node.getAcParentId() == 0) {
                resultArticleNodes.add(node);
                // 递归获取二级、三级、。。。节点
                buildArticleClass(node);
            }
        }
        return resultArticleNodes;
    }

    /**
     *  递归循环子节点
     * @param node  当前节点
     */
    private void buildArticleClass(ArticleClass node) {
        List<ArticleClass> children = new ArrayList<ArticleClass>();
        int id = node.getAcId();
        for (ArticleClass child : this.articleClassNodes) {
            //如果id等于父id、将该节点加入循环列表中
            if (id == child.getAcParentId()) {
                children.add(child);
            }
        }

        //如果存在子节点、将子节点遍历加入返回值中
        if (!children.isEmpty()) {
            for (ArticleClass child : children) {
                resultArticleNodes.add(child);
                buildArticleClass(child);
            }
            node.setAcChildrenId(1);  // 有子节点时，就设为1
        } else {
            node.setAcChildrenId(0);    // 没有子节点时，就设为0
        }
    }
    /************** ArticleClass ArticleClass  end*****************/
}
